Generating High-Level Interaction Models out of Ontologies

Generating user interfaces out of semantic models is still an issue because of the semantic gap between ontologies and user interfaces. We bridge this gap through semantic model-driven development. More precisely, we show how to automatically generate high-level interaction models (in the form of communication models representing discourses) out of (annotated) ontologies, using model-transformation rules. From these discourse models, user interfaces can be generated (semi-)automatically. INTRODUCTION The most important elements of any interactive system are the information it contains and the user interface through which this system communicates with its users. The information may be represented with (formal) semantic models (e.g., based on ontologies), and the user interface is typically created manually on top of such models. This requires a lot of effort, especially if these models are modified and the user interface has to be adapted manually. In a specific category of interactive systems, such as product recommendation systems, reservation systems or shopping applications, the underlying (semantic) model may strongly influence the behavior of the systems and, therefore, also the interactions to be implemented through the user interfaces. For this category of interactive systems, we address the semantic gap between underlying ontologies and user interfaces. We make use of our discourse models [1, 3] for bridging this gap. In this course, a discourse model and a domainof-discourse model together serve as a high-level interaction model and, as such, as a kind of “intermediate language” between the ontology and the user interface. In addition, such a model can even be used for the (semi-)automatic generation of a user interface [3, 10]. IUI SEMAIS Workshop 2011. The remainder of this paper is organized as in the following manner. First we give a brief background on our previous work relevant for this paper, and compare it with some of the related work in the field. Then we present our approach for generating interaction models out of (annotated) ontologies. This approach contains two parts: the generation of discourse models representing the flow of communication between the user and the computer, and the generation of domain-of-discourse models representing what they “talk about”. Finally we conclude and provide an outlook of our future work in this direction. BACKGROUND AND RELATED WORK Our previous work focused on manual modeling of interaction designs [1], where even end users created interaction designs in the form of discourse models using the graphical editor developed for this purpose. These discourse models are based on several theories of human communication [2]. The key parts of our discourse models are Communicative Acts as derived from speech acts [11], Adjacency Pairs adopted from Conversation Analysis [5], and RST relations inherited from Rhetorical Structure Theory (RST) [6]. Communicative Acts are semi-structured messages carrying the intention (e.g., asking a question or issuing a request) and represent basic units of language communication. Adjacency Pairs are sequences of talk-turns that are specific to human (oral) communication, e.g., a question should have a related answer. RST relations specify relationships among text portions and associated constraints and effects, and are organized in a tree structure. In our work, we use RST for linking Adjacency Pairs of Communicative Acts and further structures made up of RST relations. We have also included procedural constructs, to provide means to express a particular order during discourse execution, to specify repetitions or conditional execution of different discourse parts. Since such discourses cast the communication between a human and the computer on a high level, abstracting from technical details, they may even be created without any programming knowledge and experience. Instead of our discourse models, ConcurTaskTrees from Paterno et al. [7] may be used for bridging the semantic gap between ontologies and user interfaces. ConcurTaskTrees facilitate modeling tasks, that are being transformed into a user interface. Our discourse models focus more on the commu1 Copyright is held by the owner/author(s)